uno: RsaUnwrap bring-up — OAEP endianness fix + non-CRT RSA private-key import - #602

fw/plat/uno/fw/pal/src/crypto/rsa.rs:175

• In the PKCS#8 path, the code descends into the privateKey OCTET STRING but does not verify that the inner RSAPrivateKey SEQUENCE consumes the entire OCTET STRING. Without that check, extra bytes inside the OCTET STRING are silently accepted.

        let (ot, oct_start, _ol, _on) = der_tlv(der, after_alg)?;
        if ot != 0x04 {
            return None;
        }
        let (st, inner_start, _sl, _sn) = der_tlv(der, oct_start)?;

fw/plat/uno/fw/pal/src/crypto/rsa.rs:332

• buf[vault_len..].zeroize() scrubs a plain &mut [u8] using the zeroize crate, but this repo has a DMA-specific wipe primitive (DmaBuf::zeroize) that uses per-byte volatile writes + a compiler fence (fw/pal/traits/src/alloc.rs:148-160). For DMA-backed buffers, prefer wiping via DmaBuf::zeroize to match the established secret-scrub pattern.

        buf[vault_len..].zeroize();

fw/plat/uno/fw/pal/src/crypto/rsa.rs:199

• parse_rsa_priv_der currently only parses the PKCS#1 version, n, e, d integers and then returns success without confirming that the mandatory remaining PKCS#1 fields (p, q, dp, dq, qinv) are present and that the key SEQUENCE is fully consumed. This makes the parser accept malformed/truncated RSA keys (or extra trailing bytes inside the SEQUENCE) even though the comment says those fields “follow”, and it weakens input validation for untrusted recovered key material.

    // n, e, d in order (p, q, dp, dq, qinv follow but are unused for non-CRT).
    let (ns, nl, after_n) = der_int(der, p)?;
    let (es, el, after_e) = der_int(der, after_n)?;
    let (ds, dl, _after_d) = der_int(der, after_e)?;
    Some(((ns, nl), (es, el), (ds, dl)))

fw/plat/uno/fw/pal/src/asn1.rs:103

• parse_rsa_private_key currently rejects a bare PKCS#1 RSAPrivateKey (it only accepts PKCS#8 PrivateKeyInfo). This contradicts both the module docs ("PKCS#8 / PKCS#1") and the PR description, which says bare PKCS#1 is supported. Either add a PKCS#1 fallback parse or update the docs/PR description to match the actual accepted formats.

pub(crate) fn parse_rsa_private_key(der_bytes: &[u8]) -> Option<RsaPrivateKeyAsn1<'_>> {
    // The recovered wire key is always a PKCS#8 PrivateKeyInfo (the format the
    // RsaUnwrap collateral is generated in); a bare PKCS#1 RSAPrivateKey is not
    // accepted.
    let pki = RsaPrivateKeyInfo::from_der(der_bytes).ok()?;

fw/plat/uno/fw/pal/src/asn1.rs:103

• The PR description and this module’s top-level docs claim the RSA decoder handles both PKCS#8 PrivateKeyInfo and bare PKCS#1 RSAPrivateKey, but parse_rsa_private_key currently rejects bare PKCS#1 (“not accepted”). Either the docs/PR description should be updated, or the parser should accept PKCS#1 as a fallback to match the stated contract.

pub(crate) fn parse_rsa_private_key(der_bytes: &[u8]) -> Option<RsaPrivateKeyAsn1<'_>> {
    // The recovered wire key is always a PKCS#8 PrivateKeyInfo (the format the
    // RsaUnwrap collateral is generated in); a bare PKCS#1 RSAPrivateKey is not
    // accepted.
    let pki = RsaPrivateKeyInfo::from_der(der_bytes).ok()?;

fw/plat/uno/fw/pal/src/crypto/rsa.rs:266

• This comment claims the recovered plaintext DER in buf is scrubbed by a per-IO teardown, but UnoHsmIoController::drop_io currently only frees the slot (fw/plat/uno/fw/pal/src/io.rs:171-174) and reset_io_alloc only rewinds watermarks (fw/plat/uno/fw/pal/src/alloc.rs:94-98). As written, recovered RSA private key material can persist in the reused DMA buffer after both success and error paths.

        // Note: `buf` holds recovered plaintext DER (and, after assembly, the
        // staged `d` plus the leftover CRT components `p`/`q`/`dp`/`dq`/`qinv`)
        // on every path through this function. It is not scrubbed here — the
        // per-IO teardown scrub wipes the whole slot, so a local wipe would be
        // redundant work that has to be removed again.

fw/plat/uno/fw/pal/src/crypto/rsa.rs:273

• rsa_priv_der_to_vault returns early on CRT requests, parse failures, and size validation failures without scrubbing buf, and the success path leaves the DER tail (including CRT components) resident in SRAM. Since IO teardown does not currently wipe IO buffers, this leaks plaintext private-key material across IO reuse.

        if crt {
            return Err(HsmError::UnsupportedCmd);
        }

fw/plat/uno/fw/pal/src/asn1.rs:103

• The PR description says the DER parser accepts both PKCS#8 PrivateKeyInfo and bare PKCS#1 RSAPrivateKey, but this function currently rejects bare PKCS#1 by unconditionally decoding RsaPrivateKeyInfo first. Either update the behavior to fall back to PKCS#1, or adjust the PR description/docs to match.

pub(crate) fn parse_rsa_private_key(der_bytes: &[u8]) -> Option<RsaPrivateKeyAsn1<'_>> {
    // The recovered wire key is always a PKCS#8 PrivateKeyInfo (the format the
    // RsaUnwrap collateral is generated in); a bare PKCS#1 RSAPrivateKey is not
    // accepted.
    let pki = RsaPrivateKeyInfo::from_der(der_bytes).ok()?;

fw/plat/uno/fw/pal/src/crypto/rsa.rs:279

• Error exits from rsa_priv_der_to_vault (crt, parse failure, size check) return without scrubbing buf, which still contains recovered plaintext RSA private-key DER. Since DmaBuf contents persist after the scoped allocator rewinds, this can leak key material in SRAM after a failed import.

        if crt {
            return Err(HsmError::UnsupportedCmd);
        }
        // Parse + validate + capture the field layout. The `key` borrow of `buf`
        // (held by the decoded `UintRef`s) is released before the in-place
        // rewrite below.
        let Some(layout) = rsa_operand_layout(&buf[..]) else {
            return Err(HsmError::InvalidArg);
        };

fw/plat/uno/fw/pal/src/crypto/rsa.rs:290

• After in-place operand assembly, buf[vault_len..] still contains staged d and leftover DER (including CRT components like p/q/dp/dq/qinv). Without a guaranteed per-IO scrub, this should be zeroized before returning.

        assemble_rsa_operand_in_place(&mut buf[..], &layout);
        Ok((vault_len, k))

fw/plat/uno/fw/pal/src/asn1.rs:103

• parse_rsa_private_key currently rejects bare PKCS#1 RSAPrivateKey inputs (it only parses PKCS#8 PrivateKeyInfo). This contradicts both the PR description (“PKCS#8 and bare PKCS#1”) and this module’s header doc that states PKCS#8 / PKCS#1 support.

pub(crate) fn parse_rsa_private_key(der_bytes: &[u8]) -> Option<RsaPrivateKeyAsn1<'_>> {
    // The recovered wire key is always a PKCS#8 PrivateKeyInfo (the format the
    // RsaUnwrap collateral is generated in); a bare PKCS#1 RSAPrivateKey is not
    // accepted.
    let pki = RsaPrivateKeyInfo::from_der(der_bytes).ok()?;

fw/plat/uno/fw/pal/src/crypto/rsa.rs:117

• rsa_operand_layout only bounds-checks e by byte width, but it doesn’t validate the exponent value itself (e.g., it would accept an empty/zero exponent or an even exponent). Since this is decoding untrusted imported key material, reject invalid RSA public exponents to avoid importing unusable/invalid keys.

    let n = key.modulus.as_bytes();
    let e = key.public_exponent.as_bytes();
    let d = key.private_exponent.as_bytes();
    let modulus_len = n.len();
    if !matches!(modulus_len, 256 | 384 | 512) || e.len() > EXP_WIRE_LEN || d.len() > modulus_len {
        return None;
    }